
// source idl: com.erp.storage.dao.idl.StorageDao.java

#ifndef STORAGEDAO_STUB_4_APP_H
#define STORAGEDAO_STUB_4_APP_H

#include <string>
#include <sstream>
#include "app_platform/cmd_obj.h"
#include "c2cent/base/basestub4app.h"
#include "app_platform/cntl_info.h"
#include "app_platform/intf_serializable.h"
#include "app_platform/intf_service_object.h"
#include "erp/storage/ddo/overflowbillddo_storage.h"	
#include "erp/storage/ddo/disassemblebillfilterddo_storage.h"	
#include <set>	
#include <map>	
#include <vector>	
#include "erp/storage/ddo/stockddo_storage.h"	
#include "erp/storage/ddo/stockcheckitemddo_storage.h"	
#include "erp/storage/ddo/stockcheckfilterddo_storage.h"	
#include "erp/storage/ddo/disassemblebillddo_storage.h"	
#include "erp/storage/ddo/losebillddo_storage.h"	
#include "erp/storage/ddo/stockcheckmasterddo_storage.h"	
#include "erp/storage/ddo/overflowbillorlosebillfilterddo_storage.h"	
#include "erp/storage/ddo/stockfilterddo_storage.h"	
#include "erp/storage/ddo/stockbranch_relddo_storage.h"	
#include "intf_storagedao.h"

namespace erp
{
namespace storage
{
namespace dao
{
	#define STORAGEDAO_STUB4APP_VERSION "ERP_STORAGE_DAO___STORAGEDAO__STUB4APP_VERSION__1.0 2013-11-01 14:16:06"
    const std::string STORAGEDAO_STUB4APP_NOUSE = STORAGEDAO_STUB4APP_VERSION;

	const uint32_t STORAGEDAO_ADDDISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1813; /// 请求命令号
	const uint32_t STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8813; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1808; /// 请求命令号
	const uint32_t STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8808; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDSTOCK_REQ_CMD_ID = 0xc05e1801; /// 请求命令号
	const uint32_t STORAGEDAO_ADDSTOCK_RESP_CMD_ID = 0xc05e8801; /// 回应命令号
	

	const uint32_t STORAGEDAO_ADDSTOCKCHECK_REQ_CMD_ID = 0xc05e1818; /// 请求命令号
	const uint32_t STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID = 0xc05e8818; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETEDISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1814; /// 请求命令号
	const uint32_t STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8814; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1809; /// 请求命令号
	const uint32_t STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8809; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETESTOCK_REQ_CMD_ID = 0xc05e1802; /// 请求命令号
	const uint32_t STORAGEDAO_DELETESTOCK_RESP_CMD_ID = 0xc05e8802; /// 回应命令号
	

	const uint32_t STORAGEDAO_DELETESTOCKCHECK_REQ_CMD_ID = 0xc05e1819; /// 请求命令号
	const uint32_t STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID = 0xc05e8819; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_REQ_CMD_ID = 0xc05e1816; /// 请求命令号
	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID = 0xc05e8816; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLLIST_REQ_CMD_ID = 0xc05e1817; /// 请求命令号
	const uint32_t STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID = 0xc05e8817; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_REQ_CMD_ID = 0xc05e1811; /// 请求命令号
	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID = 0xc05e8811; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_REQ_CMD_ID = 0xc05e1812; /// 请求命令号
	const uint32_t STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID = 0xc05e8812; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_REQ_CMD_ID = 0xc05e1807; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID = 0xc05e8807; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKBYSYSNOS_REQ_CMD_ID = 0xc05e1804; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID = 0xc05e8804; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKCHECKBYSYSNOS_REQ_CMD_ID = 0xc05e1821; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID = 0xc05e8821; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKCHECKLIST_REQ_CMD_ID = 0xc05e1822; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID = 0xc05e8822; /// 回应命令号
	

	const uint32_t STORAGEDAO_GETSTOCKLIST_REQ_CMD_ID = 0xc05e1805; /// 请求命令号
	const uint32_t STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID = 0xc05e8805; /// 回应命令号
	

	const uint32_t STORAGEDAO_MODIFYSTOCKBRANCH_REL_REQ_CMD_ID = 0xc05e1806; /// 请求命令号
	const uint32_t STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID = 0xc05e8806; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATADISASSEMBLEBILL_REQ_CMD_ID = 0xc05e1815; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID = 0xc05e8815; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_REQ_CMD_ID = 0xc05e1810; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID = 0xc05e8810; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATASTOCKCHECK_REQ_CMD_ID = 0xc05e1820; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID = 0xc05e8820; /// 回应命令号
	

	const uint32_t STORAGEDAO_UPDATESTOCK_REQ_CMD_ID = 0xc05e1803; /// 请求命令号
	const uint32_t STORAGEDAO_UPDATESTOCK_RESP_CMD_ID = 0xc05e8803; /// 回应命令号
	


	const uint16_t STORAGEDAO_MAX_PROTOCAL_VERSION = 2; //>平台支持的最大协议版本号

///////////////////////////// STRUCTS /////////////////////////////////////////////////
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CDisassembleBillDdo DisassembleBillInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t DisassembleBillSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDDISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			DisassembleBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t DisassembleBillSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & DisassembleBillSysNo;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CLoseBillDdo LoseBillInfo;
		erp::storage::ddo::COverFlowBillDdo OverFlowBillInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t OverFlowBillSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			LoseBillInfo.Serialize(bs);
			OverFlowBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t OverFlowBillSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & OverFlowBillSysNo;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockDdo StockInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockSysNo;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockCheckMasterDdo StockCheckMasterInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockCheckMasterSysNo;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockCheckMasterInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CAddStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		uint64_t StockCheckMasterSysNo;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockCheckMasterSysNo;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > DisassemblebillSysNos;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETEDISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & DisassemblebillSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > FLoseBillSysNo;
		std::set<uint64_t > FOverFlowBillSysNo;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & FLoseBillSysNo;
			bs & FOverFlowBillSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > FStockSysNo;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & FStockSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		std::set<uint64_t > StockCheckMasterSysNos;
		std::string inReserve;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockCheckMasterSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CDeleteStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::map<uint64_t,uint32_t > errorCode;
		std::map<uint64_t,std::string > errorMsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & errorCode;
			bs & errorMsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetDisassembleBillBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > DisassembleBillSysnoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & DisassembleBillSysnoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetDisassembleBillBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & DisassembleBillList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetDisassembleBillListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CDisassembleBillFilterDdo DisassembleBillFilter;
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			DisassembleBillFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetDisassembleBillListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CDisassembleBillDdo > DisassembleBillList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & DisassembleBillList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetLoseBillOrOverFlowBillBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > LoseBillSysNoList;
		std::set<uint64_t > OverFlowSysNoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & LoseBillSysNoList;
			bs & OverFlowSysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetLoseBillOrOverFlowBillBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & LoseBillList;
			bs & OverFlowList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetLoseBillOrOverFlowBillListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo OverFlowBillOrLoseBillFilter;
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			OverFlowBillOrLoseBillFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetLoseBillOrOverFlowBillListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CLoseBillDdo > LoseBillList;
		std::vector<erp::storage::ddo::COverFlowBillDdo > OverFlowList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & LoseBillList;
			bs & OverFlowList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockBranch_RelBySysNoReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		uint64_t StockSysNo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		std::vector<erp::storage::ddo::CStockBranch_RelDdo > StockBranchList;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockSysNo;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockBranch_RelBySysNoResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
		std::vector<erp::storage::ddo::CStockBranch_RelDdo > StockBranchList;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
			bs & StockBranchList;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > StockSysnoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & StockSysnoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & StockList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockCheckBySysNosReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		std::set<uint64_t > StockCheckMasterSysNoList;
		std::string inReserve;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKBYSYSNOS_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & StockCheckMasterSysNoList;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockCheckBySysNosResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & StockCheckList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockCheckListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CStockCheckFilterDdo StockCheckFilter;
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			StockCheckFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockCheckListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockCheckMasterDdo > StockCheckList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & StockCheckList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockListReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		erp::storage::ddo::CStockFilterDdo StockFilter;
		std::string inReserve;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKLIST_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			StockFilter.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CGetStockListResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		uint32_t total;
		std::vector<erp::storage::ddo::CStockDdo > StockList;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & total;
			bs & StockList;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CModifyStockBranch_RelReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		uint64_t StockSysNo;
		std::set<uint64_t > BranchSysNos;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_MODIFYSTOCKBRANCH_REL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			bs & StockSysNo;
			bs & BranchSysNos;
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CModifyStockBranch_RelResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataDisassembleBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CDisassembleBillDdo DisassembleBillInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATADISASSEMBLEBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			DisassembleBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataDisassembleBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataLoseBillOrOverFlowBillReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CLoseBillDdo LoseBillInfo;
		erp::storage::ddo::COverFlowBillDdo OverFlowBillInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			LoseBillInfo.Serialize(bs);
			OverFlowBillInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataLoseBillOrOverFlowBillResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataStockCheckReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockCheckMasterDdo StockCheckMasterInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATASTOCKCHECK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockCheckMasterInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdataStockCheckResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	/**
	 *
 	 * 
	 *
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdateStockReq : public IServiceObject, public ISerializableXML
	{
		std::string machineKey;
		std::string source;
		uint32_t sceneId;
		uint32_t option;
		erp::storage::ddo::CStockDdo StockInfo;
		std::string inReserve;
		std::string errmsg;
		std::string outReserve;
		
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATESTOCK_REQ_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
			//检查协议的版本号
		    //if(bs.getVersion() > STORAGEDAO_MAX_PROTOCAL_VERSION)
		    //return false;
			bs & machineKey;
			bs & source;
			bs & sceneId;
			bs & option;
			StockInfo.Serialize(bs);
			bs & inReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	
	/**
	 *
 	 * 
	 *
 	 * @date 2013-11-01 14:16:06
 	 * @version 0
	 */	
	struct CUpdateStockResp : public IServiceObject, public ISerializableXML
	{
		uint32_t dwResult;
		std::string errmsg;
		std::string outReserve;
	
	    virtual uint32_t getCmdId() const { return STORAGEDAO_UPDATESTOCK_RESP_CMD_ID; }
		virtual bool Serialize(CByteStreamNetwork& bs)
		{
		    bs & dwResult;
			bs & errmsg;
			bs & outReserve;
		    return bs.isGood();
		}
	    virtual void Dump(std::ostream& os)	{}
	
		virtual bool FromXML(const std::string& sXMLContent) { return true; }
		virtual bool ToXML(std::string& sXMLContent) { return true; }
	};
	class CStorageDaoStub4App : public c2cent::CBaseStub4App, public IStorageDao,public IStorageDaoAsyc{
		public:
			uint32_t AddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
			);
			
			uint32_t SendAddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvAddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
		    );
		    
		    uint32_t RecvAddDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
		    );
		    
		    uint32_t GetAddDisassembleBillRespCmd(
		    );
			uint32_t AddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
			);
			
			uint32_t SendAddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvAddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
		    );
		    
		    uint32_t RecvAddLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
		    );
		    
		    uint32_t GetAddLoseBillOrOverFlowBillRespCmd(
		    );
			uint32_t AddStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
			);
			
			uint32_t SendAddStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvAddStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
		    );
		    
		    uint32_t RecvAddStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
		    );
		    
		    uint32_t GetAddStockRespCmd(
		    );
			uint32_t AddStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
			);
			
			uint32_t SendAddStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvAddStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
		    );
		    
		    uint32_t RecvAddStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
		    );
		    
		    uint32_t GetAddStockCheckRespCmd(
		    );
			uint32_t DeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& DisassemblebillSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& DisassemblebillSysNos,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteDisassembleBillRespCmd(
		    );
			uint32_t DeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FLoseBillSysNo,
				const std::set<uint64_t >& FOverFlowBillSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FLoseBillSysNo,
				const std::set<uint64_t >& FOverFlowBillSysNo,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteLoseBillOrOverFlowBillRespCmd(
		    );
			uint32_t DeleteStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FStockSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FStockSysNo,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteStockRespCmd(
		    );
			uint32_t DeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& StockCheckMasterSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
			);
			
			uint32_t SendDeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& StockCheckMasterSysNos,
				const std::string& inReserve
		    );
		    uint32_t RecvDeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvDeleteStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetDeleteStockCheckRespCmd(
		    );
			uint32_t GetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& DisassembleBillSysnoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
			);
			
			uint32_t SendGetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& DisassembleBillSysnoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetDisassembleBillBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetDisassembleBillBySysNosRespCmd(
		    );
			uint32_t GetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CDisassembleBillFilterDdo& DisassembleBillFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
			);
			
			uint32_t SendGetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CDisassembleBillFilterDdo& DisassembleBillFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetDisassembleBillList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetDisassembleBillListRespCmd(
		    );
			uint32_t GetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& LoseBillSysNoList,
				const std::set<uint64_t >& OverFlowSysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
			);
			
			uint32_t SendGetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& LoseBillSysNoList,
				const std::set<uint64_t >& OverFlowSysNoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetLoseBillOrOverFlowBillBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetLoseBillOrOverFlowBillBySysNosRespCmd(
		    );
			uint32_t GetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo& OverFlowBillOrLoseBillFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
			);
			
			uint32_t SendGetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo& OverFlowBillOrLoseBillFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetLoseBillOrOverFlowBillList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetLoseBillOrOverFlowBillListRespCmd(
		    );
			uint32_t GetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
			);
			
			uint32_t SendGetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::string& inReserve
		    );
		    uint32_t RecvGetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
		    );
		    
		    uint32_t RecvGetStockBranch_RelBySysNo(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
		    );
		    
		    uint32_t GetGetStockBranch_RelBySysNoRespCmd(
		    );
			uint32_t GetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockSysnoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
			);
			
			uint32_t SendGetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockSysnoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetStockBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetStockBySysNosRespCmd(
		    );
			uint32_t GetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockCheckMasterSysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
			);
			
			uint32_t SendGetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockCheckMasterSysNoList,
				const std::string& inReserve
		    );
		    uint32_t RecvGetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetStockCheckBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetStockCheckBySysNosRespCmd(
		    );
			uint32_t GetStockCheckList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockCheckFilterDdo& StockCheckFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
			);
			
			uint32_t SendGetStockCheckList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockCheckFilterDdo& StockCheckFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetStockCheckList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetStockCheckList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetStockCheckListRespCmd(
		    );
			uint32_t GetStockList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockFilterDdo& StockFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
			);
			
			uint32_t SendGetStockList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockFilterDdo& StockFilter,
				const std::string& inReserve
		    );
		    uint32_t RecvGetStockList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
		    );
		    
		    uint32_t RecvGetStockList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
		    );
		    
		    uint32_t GetGetStockListRespCmd(
		    );
			uint32_t ModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::set<uint64_t >& BranchSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::set<uint64_t >& BranchSysNos,
				const std::string& inReserve
		    );
		    uint32_t RecvModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvModifyStockBranch_Rel(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetModifyStockBranch_RelRespCmd(
		    );
			uint32_t UpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendUpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvUpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvUpdataDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetUpdataDisassembleBillRespCmd(
		    );
			uint32_t UpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendUpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvUpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvUpdataLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetUpdataLoseBillOrOverFlowBillRespCmd(
		    );
			uint32_t UpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendUpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvUpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvUpdataStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetUpdataStockCheckRespCmd(
		    );
			uint32_t UpdateStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
			);
			
			uint32_t SendUpdateStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve
		    );
		    uint32_t RecvUpdateStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t RecvUpdateStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
		    );
		    
		    uint32_t GetUpdateStockRespCmd(
		    );
	};
	
	/**
	 *
 	 *  拆装单创建 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param DisassembleBillDdo DisassembleBillInfo: 拆装单信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
		 *@param uint64_t DisassembleBillSysNo: 返回添加成功的SysNo  		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::AddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
	)
	{
		CAddDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassembleBillInfo = DisassembleBillInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
			oReq.DisassembleBillSysNo = DisassembleBillSysNo;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			DisassembleBillSysNo  = oResp.DisassembleBillSysNo;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendAddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve
	)
	{
	    CAddDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassembleBillInfo = DisassembleBillInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvAddDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			DisassembleBillSysNo  = oResp.DisassembleBillSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvAddDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& DisassembleBillSysNo
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			DisassembleBillSysNo  = oResp.DisassembleBillSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetAddDisassembleBillRespCmd(
	)
	{	    
	    return STORAGEDAO_ADDDISASSEMBLEBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  写入报损/报溢表 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param LoseBillDdo LoseBillInfo: 报损表信息，必填  				
		 *@param OverFlowBillDdo OverFlowBillInfo: 报溢表信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
		 *@param uint64_t OverFlowBillSysNo: 返回添加成功的SysNo  		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::AddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
	)
	{
		CAddLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.LoseBillInfo = LoseBillInfo;
			oReq.OverFlowBillInfo = OverFlowBillInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
			oReq.OverFlowBillSysNo = OverFlowBillSysNo;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			OverFlowBillSysNo  = oResp.OverFlowBillSysNo;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendAddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve
	)
	{
	    CAddLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.LoseBillInfo = LoseBillInfo;
			oReq.OverFlowBillInfo = OverFlowBillInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvAddLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			OverFlowBillSysNo  = oResp.OverFlowBillSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvAddLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& OverFlowBillSysNo
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			OverFlowBillSysNo  = oResp.OverFlowBillSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetAddLoseBillOrOverFlowBillRespCmd(
	)
	{	    
	    return STORAGEDAO_ADDLOSEBILLOROVERFLOWBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  写入仓库信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param StockDdo StockInfo: 仓库信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
		 *@param uint64_t StockSysNo: 返回添加成功的SysNo  		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::AddStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
	)
	{
		CAddStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockInfo = StockInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
			oReq.StockSysNo = StockSysNo;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDSTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDSTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockSysNo  = oResp.StockSysNo;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendAddStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve
	)
	{
	    CAddStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockInfo = StockInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvAddStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDSTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDSTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockSysNo  = oResp.StockSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvAddStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockSysNo
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockSysNo  = oResp.StockSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetAddStockRespCmd(
	)
	{	    
	    return STORAGEDAO_ADDSTOCK_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  盘点单创建 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param StockCheckMasterDdo StockCheckMasterInfo: 盘点单信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
		 *@param uint64_t StockCheckMasterSysNo: 返回添加成功的SysNo  		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::AddStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
	)
	{
		CAddStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterInfo = StockCheckMasterInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
			oReq.StockCheckMasterSysNo = StockCheckMasterSysNo;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockCheckMasterSysNo  = oResp.StockCheckMasterSysNo;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendAddStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve
	)
	{
	    CAddStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterInfo = StockCheckMasterInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvAddStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockCheckMasterSysNo  = oResp.StockCheckMasterSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvAddStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				uint64_t& StockCheckMasterSysNo
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CAddStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockCheckMasterSysNo  = oResp.StockCheckMasterSysNo;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetAddStockCheckRespCmd(
	)
	{	    
	    return STORAGEDAO_ADDSTOCKCHECK_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  拆装单删除（逻辑） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param Set DisassemblebillSysNos: 需删除的拆装单SysNos，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map errorCode: 删除失败的错误码 		
		 *@param Map errorMsg: 删除失败的错误信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::DeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& DisassemblebillSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CDeleteDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassemblebillSysNos = DisassemblebillSysNos;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.errorCode = errorCode;
			oReq.errorMsg = errorMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendDeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& DisassemblebillSysNos,
				const std::string& inReserve
	)
	{
	    CDeleteDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassemblebillSysNos = DisassemblebillSysNos;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvDeleteDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvDeleteDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetDeleteDisassembleBillRespCmd(
	)
	{	    
	    return STORAGEDAO_DELETEDISASSEMBLEBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  逻辑删除报损/报溢表  
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param Set FLoseBillSysNo: 需删除的报损ID，必填  				
		 *@param Set FOverFlowBillSysNo: 需删除的报溢ID，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map errorCode: 删除失败的错误码 		
		 *@param Map errorMsg: 删除失败的错误信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::DeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FLoseBillSysNo,
				const std::set<uint64_t >& FOverFlowBillSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CDeleteLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.FLoseBillSysNo = FLoseBillSysNo;
			oReq.FOverFlowBillSysNo = FOverFlowBillSysNo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.errorCode = errorCode;
			oReq.errorMsg = errorMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendDeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FLoseBillSysNo,
				const std::set<uint64_t >& FOverFlowBillSysNo,
				const std::string& inReserve
	)
	{
	    CDeleteLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.FLoseBillSysNo = FLoseBillSysNo;
			oReq.FOverFlowBillSysNo = FOverFlowBillSysNo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvDeleteLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvDeleteLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetDeleteLoseBillOrOverFlowBillRespCmd(
	)
	{	    
	    return STORAGEDAO_DELETELOSEBILLOROVERFLOWBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  逻辑删除仓库信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param Set FStockSysNo: 需删除的仓库ID，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map errorCode: 删除失败的错误码 		
		 *@param Map errorMsg: 删除失败的错误信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::DeleteStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FStockSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CDeleteStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.FStockSysNo = FStockSysNo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.errorCode = errorCode;
			oReq.errorMsg = errorMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETESTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETESTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendDeleteStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& FStockSysNo,
				const std::string& inReserve
	)
	{
	    CDeleteStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.FStockSysNo = FStockSysNo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvDeleteStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETESTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETESTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvDeleteStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetDeleteStockRespCmd(
	)
	{	    
	    return STORAGEDAO_DELETESTOCK_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  盘点单删除（逻辑） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param Set StockCheckMasterSysNos: 需删除的拆装单SysNos，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Map errorCode: 删除失败的错误码 		
		 *@param Map errorMsg: 删除失败的错误信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::DeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& StockCheckMasterSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CDeleteStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterSysNos = StockCheckMasterSysNos;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.errorCode = errorCode;
			oReq.errorMsg = errorMsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendDeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const std::set<uint64_t >& StockCheckMasterSysNos,
				const std::string& inReserve
	)
	{
	    CDeleteStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterSysNos = StockCheckMasterSysNos;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvDeleteStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvDeleteStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::map<uint64_t,uint32_t >& errorCode,
				std::map<uint64_t,std::string >& errorMsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CDeleteStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			errorCode  = oResp.errorCode;
			errorMsg  = oResp.errorMsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetDeleteStockCheckRespCmd(
	)
	{	    
	    return STORAGEDAO_DELETESTOCKCHECK_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  拆装单查询（主键） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set DisassembleBillSysnoList: 需获取的仓库sysnos，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector DisassembleBillList: 拆装单信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& DisassembleBillSysnoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{
		CGetDisassembleBillBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.DisassembleBillSysnoList = DisassembleBillSysnoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.DisassembleBillList = DisassembleBillList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& DisassembleBillSysnoList,
				const std::string& inReserve
	)
	{
	    CGetDisassembleBillBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.DisassembleBillSysnoList = DisassembleBillSysnoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetDisassembleBillBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetDisassembleBillBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetDisassembleBillBySysNosRespCmd(
	)
	{	    
	    return STORAGEDAO_GETDISASSEMBLEBILLBYSYSNOS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  拆装单列表（列表过滤） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param DisassembleBillFilterDdo DisassembleBillFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint32_t total: 信息总数 		
		 *@param Vector DisassembleBillList: 拆装单信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CDisassembleBillFilterDdo& DisassembleBillFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{
		CGetDisassembleBillListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.DisassembleBillFilter = DisassembleBillFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.total = total;
			oReq.DisassembleBillList = DisassembleBillList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CDisassembleBillFilterDdo& DisassembleBillFilter,
				const std::string& inReserve
	)
	{
	    CGetDisassembleBillListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.DisassembleBillFilter = DisassembleBillFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetDisassembleBillList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetDisassembleBillList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CDisassembleBillDdo >& DisassembleBillList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetDisassembleBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			DisassembleBillList  = oResp.DisassembleBillList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetDisassembleBillListRespCmd(
	)
	{	    
	    return STORAGEDAO_GETDISASSEMBLEBILLLIST_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  根据ID获取报损/报溢表信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set LoseBillSysNoList: 需获取的仓库sysnos，必填  				
		 *@param Set OverFlowSysNoList: 需获取的仓库sysnos，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector LoseBillList: 报损列表信息 		
		 *@param Vector OverFlowList: 报溢列表信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& LoseBillSysNoList,
				const std::set<uint64_t >& OverFlowSysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{
		CGetLoseBillOrOverFlowBillBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.LoseBillSysNoList = LoseBillSysNoList;
			oReq.OverFlowSysNoList = OverFlowSysNoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.LoseBillList = LoseBillList;
			oReq.OverFlowList = OverFlowList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& LoseBillSysNoList,
				const std::set<uint64_t >& OverFlowSysNoList,
				const std::string& inReserve
	)
	{
	    CGetLoseBillOrOverFlowBillBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.LoseBillSysNoList = LoseBillSysNoList;
			oReq.OverFlowSysNoList = OverFlowSysNoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetLoseBillOrOverFlowBillBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetLoseBillOrOverFlowBillBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetLoseBillOrOverFlowBillBySysNosRespCmd(
	)
	{	    
	    return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLBYSYSNOS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  根据filter获取报损/报溢表
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param OverFlowBillOrLoseBillFilterDdo OverFlowBillOrLoseBillFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint32_t total: 信息总数 		
		 *@param Vector LoseBillList: 报损列表信息 		
		 *@param Vector OverFlowList: 报溢列表信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo& OverFlowBillOrLoseBillFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{
		CGetLoseBillOrOverFlowBillListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.OverFlowBillOrLoseBillFilter = OverFlowBillOrLoseBillFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.total = total;
			oReq.LoseBillList = LoseBillList;
			oReq.OverFlowList = OverFlowList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::COverFlowBillOrLoseBillFilterDdo& OverFlowBillOrLoseBillFilter,
				const std::string& inReserve
	)
	{
	    CGetLoseBillOrOverFlowBillListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.OverFlowBillOrLoseBillFilter = OverFlowBillOrLoseBillFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetLoseBillOrOverFlowBillList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetLoseBillOrOverFlowBillList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CLoseBillDdo >& LoseBillList,
				std::vector<erp::storage::ddo::COverFlowBillDdo >& OverFlowList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetLoseBillOrOverFlowBillListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			LoseBillList  = oResp.LoseBillList;
			OverFlowList  = oResp.OverFlowList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetLoseBillOrOverFlowBillListRespCmd(
	)
	{	    
	    return STORAGEDAO_GETLOSEBILLOROVERFLOWBILLLIST_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  查询仓库与分支机构关系 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param uint64_t StockSysNo: 仓库sys，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
		 *@param Vector StockBranchList: 仓库与分支机构关系列表信息 		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
	)
	{
		CGetStockBranch_RelBySysNoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockSysNo = StockSysNo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
			oReq.StockBranchList = StockBranchList;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBranch_RelBySysNoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockBranchList  = oResp.StockBranchList;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::string& inReserve
	)
	{
	    CGetStockBranch_RelBySysNoReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockSysNo = StockSysNo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetStockBranch_RelBySysNo(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBranch_RelBySysNoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockBranchList  = oResp.StockBranchList;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetStockBranch_RelBySysNo(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve,
				std::vector<erp::storage::ddo::CStockBranch_RelDdo >& StockBranchList
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBranch_RelBySysNoResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
			StockBranchList  = oResp.StockBranchList;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetStockBranch_RelBySysNoRespCmd(
	)
	{	    
	    return STORAGEDAO_GETSTOCKBRANCH_RELBYSYSNO_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  根据ID获取仓库信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set StockSysnoList: 需获取的仓库ID，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector StockList: 仓库列表信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockSysnoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{
		CGetStockBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockSysnoList = StockSysnoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.StockList = StockList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockSysnoList,
				const std::string& inReserve
	)
	{
	    CGetStockBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockSysnoList = StockSysnoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetStockBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetStockBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetStockBySysNosRespCmd(
	)
	{	    
	    return STORAGEDAO_GETSTOCKBYSYSNOS_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  盘点单查询（主键） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param Set StockCheckMasterSysNoList: 需获取的仓库sysnos，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param Vector StockCheckList: 盘点单信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockCheckMasterSysNoList,
				const std::string& inReserve,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{
		CGetStockCheckBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockCheckMasterSysNoList = StockCheckMasterSysNoList;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.StockCheckList = StockCheckList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const std::set<uint64_t >& StockCheckMasterSysNoList,
				const std::string& inReserve
	)
	{
	    CGetStockCheckBySysNosReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockCheckMasterSysNoList = StockCheckMasterSysNoList;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetStockCheckBySysNos(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetStockCheckBySysNos(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckBySysNosResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetStockCheckBySysNosRespCmd(
	)
	{	    
	    return STORAGEDAO_GETSTOCKCHECKBYSYSNOS_RESP_CMD_ID;
	}	
	/**
	 *
 	 * 盘点单列表（列表过滤） 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param StockCheckFilterDdo StockCheckFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint32_t total: 信息总数 		
		 *@param Vector StockCheckList: 盘点单信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetStockCheckList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockCheckFilterDdo& StockCheckFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{
		CGetStockCheckListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockCheckFilter = StockCheckFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.total = total;
			oReq.StockCheckList = StockCheckList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetStockCheckList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockCheckFilterDdo& StockCheckFilter,
				const std::string& inReserve
	)
	{
	    CGetStockCheckListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockCheckFilter = StockCheckFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetStockCheckList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetStockCheckList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockCheckMasterDdo >& StockCheckList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockCheckListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockCheckList  = oResp.StockCheckList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetStockCheckListRespCmd(
	)
	{	    
	    return STORAGEDAO_GETSTOCKCHECKLIST_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  根据filter获取仓库信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param StockFilterDdo StockFilter: 过滤器，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param uint32_t total: 仓库总数 		
		 *@param Vector StockList: 仓库列表信息 		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::GetStockList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockFilterDdo& StockFilter,
				const std::string& inReserve,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{
		CGetStockListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockFilter = StockFilter;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.total = total;
			oReq.StockList = StockList;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendGetStockList(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				const erp::storage::ddo::CStockFilterDdo& StockFilter,
				const std::string& inReserve
	)
	{
	    CGetStockListReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.StockFilter = StockFilter;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvGetStockList(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvGetStockList(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				uint32_t& total,
				std::vector<erp::storage::ddo::CStockDdo >& StockList,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CGetStockListResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			total  = oResp.total;
			StockList  = oResp.StockList;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetGetStockListRespCmd(
	)
	{	    
	    return STORAGEDAO_GETSTOCKLIST_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  维护仓库与分支机构关系 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param uint64_t StockSysNo: 仓库sys，必填  				
		 *@param Set BranchSysNos: 仓库sys，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::ModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::set<uint64_t >& BranchSysNos,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CModifyStockBranch_RelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockSysNo = StockSysNo;
			oReq.BranchSysNos = BranchSysNos;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CModifyStockBranch_RelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				uint64_t StockSysNo,
				const std::set<uint64_t >& BranchSysNos,
				const std::string& inReserve
	)
	{
	    CModifyStockBranch_RelReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockSysNo = StockSysNo;
			oReq.BranchSysNos = BranchSysNos;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvModifyStockBranch_Rel(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CModifyStockBranch_RelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvModifyStockBranch_Rel(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CModifyStockBranch_RelResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetModifyStockBranch_RelRespCmd(
	)
	{	    
	    return STORAGEDAO_MODIFYSTOCKBRANCH_REL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  拆装单修改 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param DisassembleBillDdo DisassembleBillInfo: 拆装单信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::UpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CUpdataDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassembleBillInfo = DisassembleBillInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendUpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CDisassembleBillDdo& DisassembleBillInfo,
				const std::string& inReserve
	)
	{
	    CUpdataDisassembleBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.DisassembleBillInfo = DisassembleBillInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvUpdataDisassembleBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvUpdataDisassembleBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataDisassembleBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetUpdataDisassembleBillRespCmd(
	)
	{	    
	    return STORAGEDAO_UPDATADISASSEMBLEBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  修改报损/报溢表 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param LoseBillDdo LoseBillInfo: 报损表信息，必填  				
		 *@param OverFlowBillDdo OverFlowBillInfo: 报溢表信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::UpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CUpdataLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.LoseBillInfo = LoseBillInfo;
			oReq.OverFlowBillInfo = OverFlowBillInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendUpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CLoseBillDdo& LoseBillInfo,
				const erp::storage::ddo::COverFlowBillDdo& OverFlowBillInfo,
				const std::string& inReserve
	)
	{
	    CUpdataLoseBillOrOverFlowBillReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.LoseBillInfo = LoseBillInfo;
			oReq.OverFlowBillInfo = OverFlowBillInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvUpdataLoseBillOrOverFlowBill(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvUpdataLoseBillOrOverFlowBill(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataLoseBillOrOverFlowBillResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetUpdataLoseBillOrOverFlowBillRespCmd(
	)
	{	    
	    return STORAGEDAO_UPDATALOSEBILLOROVERFLOWBILL_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  盘点单修改 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param StockCheckMasterDdo StockCheckMasterInfo: 盘点单信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::UpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CUpdataStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterInfo = StockCheckMasterInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendUpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockCheckMasterDdo& StockCheckMasterInfo,
				const std::string& inReserve
	)
	{
	    CUpdataStockCheckReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockCheckMasterInfo = StockCheckMasterInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvUpdataStockCheck(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvUpdataStockCheck(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdataStockCheckResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetUpdataStockCheckRespCmd(
	)
	{	    
	    return STORAGEDAO_UPDATASTOCKCHECK_RESP_CMD_ID;
	}	
	/**
	 *
 	 *  修改仓库信息 
	 *
		 *@param String machineKey: 机器码，必填  				
		 *@param String source: 调用来源，必填  				
		 *@param uint32_t sceneId: 场景id，必填  				
		 *@param uint32_t option: 功能选项，扩展选填  				
		 *@param StockDdo StockInfo: 仓库信息，必填  				
		 *@param String inReserve: 请求保留字  				
		 *@param String errmsg: 错误信息  		
		 *@param String outReserve: 返回保留字   		
     *
     *@return uint32_t : 0(成功) 其它失败
	 */	
	inline uint32_t CStorageDaoStub4App::UpdateStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CUpdateStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockInfo = StockInfo;
			oReq.inReserve = inReserve;
			oReq.errmsg = errmsg;
			oReq.outReserve = outReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
	
	    if((iRetCode = m_pSvcCntl->schedule()) != 0)
	    {
	        m_sErrMsg = "schedule failed.";
	        return 0xFFF2;
	    }
	    
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATESTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATESTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
            return 0xEE0029;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0030;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	inline uint32_t CStorageDaoStub4App::SendUpdateStock(
				const CCntlInfo& rCntlInfo,
				const std::string& machineKey,
				const std::string& source,
				uint32_t sceneId,
				uint32_t option,
				const erp::storage::ddo::CStockDdo& StockInfo,
				const std::string& inReserve
	)
	{
	    CUpdateStockReq oReq;
			oReq.machineKey = machineKey;
			oReq.source = source;
			oReq.sceneId = sceneId;
			oReq.option = option;
			oReq.StockInfo = StockInfo;
			oReq.inReserve = inReserve;
	
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    if (m_pSvcCntl == NULL)
        {
            m_sErrMsg = "error, rCntlInfo is temporary variable";
            return 0xEE0041;
        }
	    int iRetCode = 0;
	    if((iRetCode = m_pSvcCntl->putSvcObj(&oReq, pCntlInfo->getRouteKey())) != 0)
	    {
	    	m_sErrMsg = "DoRequest failed.";
	        return iRetCode;
	    }
		return 0;
	}
	inline uint32_t CStorageDaoStub4App::RecvUpdateStock(
				const CCntlInfo& rCntlInfo,
				std::string& errmsg,
				std::string& outReserve
	)
	{
		CCntlInfo* pCntlInfo = const_cast<CCntlInfo*>(&rCntlInfo);
	    m_pSvcCntl = reinterpret_cast<IServiceControl*>(pCntlInfo->getCntl());
	    CCmdObj& rCmd = m_pSvcCntl->getRespObj();
	    if(!rCmd.isValid(STORAGEDAO_UPDATESTOCK_RESP_CMD_ID))
	    {
	    	std::stringstream oss;
            oss << "Cmd not match: "
                << "expected cmd=" << std::hex << STORAGEDAO_UPDATESTOCK_RESP_CMD_ID << std::dec << " != "
                << "actualed cmd=" << std::hex << rCmd.getCmdId() << std::dec;
            m_sErrMsg = oss.str();
	        return 0xEE0031;
	    }
	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0032;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::RecvUpdateStock(
		  		CCmdObj& rCmd,
				std::string& errmsg,
				std::string& outReserve
	)
	{	    
	    char* pBuf = NULL; uint32_t nLen = 0;
	    rCmd.getBuffer(pBuf, nLen);
	    CByteStreamNetwork bs(pBuf, nLen);
	    bs.isStoring(false);
	    
	    CUpdateStockResp oResp;
	    if(!oResp.Serialize(bs))
	    {
	        m_sErrMsg = "Resp.Serialize(bs) failed";
	        return 0xEE0033;
	    }
			errmsg  = oResp.errmsg;
			outReserve  = oResp.outReserve;
	    
	    return oResp.dwResult;
	}
	
	inline uint32_t CStorageDaoStub4App::GetUpdateStockRespCmd(
	)
	{	    
	    return STORAGEDAO_UPDATESTOCK_RESP_CMD_ID;
	}	
		
}
}
}

#endif /* STORAGEDAO_STUB_4_APP_H */
